#line 2 "lua.stx"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "opcode.h"
#include "hash.h"
#include "inout.h"
#include "table.h"
#include "lua.h"

#ifndef ALIGNMENT
#define ALIGNMENT (sizeof(void *))
#endif

#ifndef MAXCODE
#define MAXCODE 1024
#endif
static long buffer[MAXCODE];
static Byte *code = (Byte *)buffer;
static long mainbuffer[MAXCODE];
static Byte *maincode = (Byte *)mainbuffer;
static Byte *basepc;
static Byte *pc;

#define MAXVAR 32
static long varbuffer[MAXVAR];
static Byte nvarbuffer = 0; /* number of variables at a list */

static Word localvar[STACKGAP];
static Byte nlocalvar = 0; /* number of local variables */
static int ntemp;          /* number of temporary var into stack */
static int err;            /* flag to indicate error */

/* Internal functions */
#define align(n) align_n(sizeof(n))

int yyparse();
extern int yylex();

static void code_byte(Byte c)
{
    if (pc - basepc > MAXCODE - 1)
    {
        lua_error("code buffer overflow");
        err = 1;
    }
    *pc++ = c;
}

static void code_word(Word n)
{
    if (pc - basepc > MAXCODE - sizeof(Word))
    {
        lua_error("code buffer overflow");
        err = 1;
    }
    *((Word *)pc) = n;
    pc += sizeof(Word);
}

static void code_float(float n)
{
    if (pc - basepc > MAXCODE - sizeof(float))
    {
        lua_error("code buffer overflow");
        err = 1;
    }
    *((float *)pc) = n;
    pc += sizeof(float);
}

static void incr_ntemp(void)
{
    if (ntemp + nlocalvar + MAXVAR + 1 < STACKGAP)
        ntemp++;
    else
    {
        lua_error("stack overflow");
        err = 1;
    }
}

static void incr_nlocalvar(void)
{
    if (ntemp + nlocalvar + MAXVAR + 1 < STACKGAP)
        nlocalvar++;
    else
    {
        lua_error("too many local variables or expression too complicate");
        err = 1;
    }
}

static void incr_nvarbuffer(void)
{
    if (nvarbuffer < MAXVAR - 1)
        nvarbuffer++;
    else
    {
        lua_error("variable buffer overflow");
        err = 1;
    }
}

static void align_n(unsigned size)
{
    if (size > ALIGNMENT)
        size = ALIGNMENT;
    while (((pc + 1 - code) % size) != 0) /* +1 to include BYTECODE */
        code_byte(NOP);
}

static void code_number(float f)
{
    int i = f;
    if (f == i) /* f has an integer value */
    {
        if (i <= 2)
            code_byte(PUSH0 + i);
        else if (i <= 255)
        {
            code_byte(PUSHBYTE);
            code_byte(i);
        }
        else
        {
            align(Word);
            code_byte(PUSHWORD);
            code_word(i);
        }
    }
    else
    {
        align(float);
        code_byte(PUSHFLOAT);
        code_float(f);
    }
    incr_ntemp();
}

#line 140 "lua.stx"
typedef union
{
    int vInt;
    long vLong;
    float vFloat;
    Word vWord;
    Byte *pByte;
} YYSTYPE;
#define NIL 257
#define IF 258
#define THEN 259
#define ELSE 260
#define ELSEIF 261
#define WHILE 262
#define DO 263
#define REPEAT 264
#define UNTIL 265
#define END 266
#define RETURN 267
#define LOCAL 268
#define NUMBER 269
#define FUNCTION 270
#define NAME 271
#define STRING 272
#define DEBUG 273
#define NOT 274
#define AND 275
#define OR 276
#define NE 277
#define LE 278
#define GE 279
#define CONC 280
#define UNARY 281
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
#define YYERRCODE 256

#line 530 "lua.stx"

/*
** Search a local name and if find return its index. If do not find return -1
*/
static int lua_localname(Word n)
{
    int i;
    for (i = nlocalvar - 1; i >= 0; i--)
        if (n == localvar[i])
            return i; /* local var */
    return -1;        /* global var */
}

/*
** Push a variable given a number. If number is positive, push global variable
** indexed by (number -1). If negative, push local indexed by ABS(number)-1.
** Otherwise, if zero, push indexed variable (record).
*/
static void lua_pushvar(long number)
{
    if (number > 0) /* global var */
    {
        align(Word);
        code_byte(PUSHGLOBAL);
        code_word(number - 1);
        incr_ntemp();
    }
    else if (number < 0) /* local var */
    {
        number = (-number) - 1;
        if (number < 10)
            code_byte(PUSHLOCAL0 + number);
        else
        {
            code_byte(PUSHLOCAL);
            code_byte(number);
        }
        incr_ntemp();
    }
    else
    {
        code_byte(PUSHINDEXED);
        ntemp--;
    }
}

static void lua_codeadjust(int n)
{
    code_byte(ADJUST);
    code_byte(n + nlocalvar);
}

static void lua_codestore(int i)
{
    if (varbuffer[i] > 0) /* global var */
    {
        align(Word);
        code_byte(STOREGLOBAL);
        code_word(varbuffer[i] - 1);
    }
    else if (varbuffer[i] < 0) /* local var */
    {
        int number = (-varbuffer[i]) - 1;
        if (number < 10)
            code_byte(STORELOCAL0 + number);
        else
        {
            code_byte(STORELOCAL);
            code_byte(number);
        }
    }
    else /* indexed var */
    {
        int j;
        int upper = 0; /* number of indexed variables upper */
        int param;     /* number of itens until indexed expression */
        for (j = i + 1; j < nvarbuffer; j++)
            if (varbuffer[j] == 0)
                upper++;
        param = upper * 2 + i;
        if (param == 0)
            code_byte(STOREINDEXED0);
        else
        {
            code_byte(STOREINDEXED);
            code_byte(param);
        }
    }
}

void yyerror(char *s)
{
    static char msg[256];
    sprintf(msg, "%s near \"%s\" at line %d in file \"%s\"",
            s, lua_lasttext(), lua_linenumber, lua_filename());
    lua_error(msg);
    err = 1;
}

int yywrap(void)
{
    return 1;
}

/*
** Parse LUA code and execute global statement.
** Return 0 on success or 1 on error.
*/
int lua_parse(void)
{
    Byte *initcode = maincode;
    err = 0;
    if (yyparse() || (err == 1))
        return 1;
    *maincode++ = HALT;
    if (lua_execute(initcode))
        return 1;
    maincode = initcode;
    return 0;
}

#if 0

static void PrintCode (void)
{
 Byte *p = code;
 printf ("\n\nCODE\n");
 while (p != pc)
 {
  switch ((OpCode)*p)
  {
   case NOP:		printf ("%d    NOP\n", (p++)-code); break;
   case PUSHNIL:	printf ("%d    PUSHNIL\n", (p++)-code); break;
   case PUSH0: case PUSH1: case PUSH2:
    			printf ("%d    PUSH%c\n", p-code, *p-PUSH0+'0');
    			p++;
   			break;
   case PUSHBYTE:
    			printf ("%d    PUSHBYTE   %d\n", p-code, *(++p));
    			p++;
   			break;
   case PUSHWORD:
    			printf ("%d    PUSHWORD   %d\n", p-code, *((Word *)(p+1)));
    			p += 1 + sizeof(Word);
   			break;
   case PUSHFLOAT:
    			printf ("%d    PUSHFLOAT  %f\n", p-code, *((float *)(p+1)));
    			p += 1 + sizeof(float);
   			break;
   case PUSHSTRING:
    			printf ("%d    PUSHSTRING   %d\n", p-code, *((Word *)(p+1)));
    			p += 1 + sizeof(Word);
   			break;
   case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
   case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
   case PUSHLOCAL8: case PUSHLOCAL9:
    			printf ("%d    PUSHLOCAL%c\n", p-code, *p-PUSHLOCAL0+'0');
    			p++;
   			break;
   case PUSHLOCAL:	printf ("%d    PUSHLOCAL   %d\n", p-code, *(++p));
    			p++;
   			break;
   case PUSHGLOBAL:
    			printf ("%d    PUSHGLOBAL   %d\n", p-code, *((Word *)(p+1)));
    			p += 1 + sizeof(Word);
   			break;
   case PUSHINDEXED:    printf ("%d    PUSHINDEXED\n", (p++)-code); break;
   case PUSHMARK:       printf ("%d    PUSHMARK\n", (p++)-code); break;
   case PUSHOBJECT:     printf ("%d    PUSHOBJECT\n", (p++)-code); break;
   case STORELOCAL0: case STORELOCAL1: case STORELOCAL2: case STORELOCAL3:
   case STORELOCAL4: case STORELOCAL5: case STORELOCAL6: case STORELOCAL7:
   case STORELOCAL8: case STORELOCAL9:
    			printf ("%d    STORELOCAL%c\n", p-code, *p-STORELOCAL0+'0');
    			p++;
   			break;
   case STORELOCAL:
    			printf ("%d    STORELOCAK   %d\n", p-code, *(++p));
    			p++;
   			break;
   case STOREGLOBAL:
    			printf ("%d    STOREGLOBAL   %d\n", p-code, *((Word *)(p+1)));
    			p += 1 + sizeof(Word);
   			break;
   case STOREINDEXED0:  printf ("%d    STOREINDEXED0\n", (p++)-code); break;
   case STOREINDEXED:   printf ("%d    STOREINDEXED   %d\n", p-code, *(++p));
    			p++;
   			break;
   case STOREFIELD:     printf ("%d    STOREFIELD\n", (p++)-code); break;
   case ADJUST:
    			printf ("%d    ADJUST   %d\n", p-code, *(++p));
    			p++;
   			break;
   case CREATEARRAY:	printf ("%d    CREATEARRAY\n", (p++)-code); break;
   case EQOP:       	printf ("%d    EQOP\n", (p++)-code); break;
   case LTOP:       	printf ("%d    LTOP\n", (p++)-code); break;
   case LEOP:       	printf ("%d    LEOP\n", (p++)-code); break;
   case ADDOP:       	printf ("%d    ADDOP\n", (p++)-code); break;
   case SUBOP:       	printf ("%d    SUBOP\n", (p++)-code); break;
   case MULTOP:      	printf ("%d    MULTOP\n", (p++)-code); break;
   case DIVOP:       	printf ("%d    DIVOP\n", (p++)-code); break;
   case CONCOP:       	printf ("%d    CONCOP\n", (p++)-code); break;
   case MINUSOP:       	printf ("%d    MINUSOP\n", (p++)-code); break;
   case NOTOP:       	printf ("%d    NOTOP\n", (p++)-code); break;
   case ONTJMP:	   
    			printf ("%d    ONTJMP  %d\n", p-code, *((Word *)(p+1)));
    			p += sizeof(Word) + 1;
   			break;
   case ONFJMP:	   
    			printf ("%d    ONFJMP  %d\n", p-code, *((Word *)(p+1)));
    			p += sizeof(Word) + 1;
   			break;
   case JMP:	   
    			printf ("%d    JMP  %d\n", p-code, *((Word *)(p+1)));
    			p += sizeof(Word) + 1;
   			break;
   case UPJMP:
    			printf ("%d    UPJMP  %d\n", p-code, *((Word *)(p+1)));
    			p += sizeof(Word) + 1;
   			break;
   case IFFJMP:
    			printf ("%d    IFFJMP  %d\n", p-code, *((Word *)(p+1)));
    			p += sizeof(Word) + 1;
   			break;
   case IFFUPJMP:
    			printf ("%d    IFFUPJMP  %d\n", p-code, *((Word *)(p+1)));
    			p += sizeof(Word) + 1;
   			break;
   case POP:       	printf ("%d    POP\n", (p++)-code); break;
   case CALLFUNC:	printf ("%d    CALLFUNC\n", (p++)-code); break;
   case RETCODE:
    			printf ("%d    RETCODE   %d\n", p-code, *(++p));
    			p++;
   			break;
   default:		printf ("%d    Cannot happen\n", (p++)-code); break;
  }
 }
}
#endif

int yyexca[] = {
    -1,
    1,
    0,
    -1,
    -2,
    2,
    -1,
    19,
    40,
    65,
    91,
    95,
    46,
    97,
    -2,
    92,
    -1,
    29,
    40,
    65,
    91,
    95,
    46,
    97,
    -2,
    51,
    -1,
    70,
    275,
    33,
    276,
    33,
    61,
    33,
    277,
    33,
    62,
    33,
    60,
    33,
    278,
    33,
    279,
    33,
    280,
    33,
    43,
    33,
    45,
    33,
    42,
    33,
    47,
    33,
    -2,
    68,
    -1,
    71,
    91,
    95,
    46,
    97,
    -2,
    93,
    -1,
    102,
    260,
    27,
    261,
    27,
    265,
    27,
    266,
    27,
    267,
    27,
    -2,
    11,
    -1,
    117,
    93,
    85,
    -2,
    87,
    -1,
    122,
    267,
    30,
    -2,
    29,
    -1,
    145,
    275,
    33,
    276,
    33,
    61,
    33,
    277,
    33,
    62,
    33,
    60,
    33,
    278,
    33,
    279,
    33,
    280,
    33,
    43,
    33,
    45,
    33,
    42,
    33,
    47,
    33,
    -2,
    70,
};
#define YYNPROD 105
#define YYLAST 318
int yyact[] = {

    54, 52, 136, 53, 13, 55, 54, 52, 14, 53,
    15, 55, 5, 166, 18, 6, 129, 21, 47, 46,
    48, 107, 104, 97, 47, 46, 48, 54, 52, 80,
    53, 21, 55, 54, 52, 40, 53, 9, 55, 54,
    52, 158, 53, 160, 55, 47, 46, 48, 159, 101,
    81, 47, 46, 48, 10, 54, 52, 126, 53, 67,
    55, 54, 52, 60, 53, 155, 55, 148, 149, 135,
    147, 108, 150, 47, 46, 48, 73, 23, 75, 47,
    46, 48, 7, 25, 38, 153, 26, 164, 27, 117,
    61, 62, 74, 11, 76, 54, 24, 127, 65, 66,
    55, 37, 154, 151, 103, 111, 72, 28, 93, 94,
    82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
    92, 116, 59, 77, 54, 52, 118, 53, 99, 55,
    110, 95, 64, 44, 70, 109, 29, 33, 105, 106,
    42, 112, 41, 165, 139, 19, 17, 152, 79, 123,
    43, 119, 20, 114, 113, 98, 63, 144, 143, 122,
    68, 39, 36, 130, 35, 120, 12, 8, 102, 125,
    128, 141, 78, 69, 70, 71, 142, 131, 132, 140,
    22, 124, 4, 3, 2, 121, 96, 138, 146, 137,
    134, 157, 133, 115, 16, 1, 0, 0, 0, 0,
    0, 0, 0, 156, 0, 0, 0, 0, 161, 0,
    0, 0, 0, 162, 0, 0, 0, 168, 0, 172,
    145, 163, 171, 0, 174, 0, 0, 0, 169, 156,
    167, 170, 173, 57, 58, 49, 50, 51, 56, 57,
    58, 49, 50, 51, 56, 175, 0, 0, 100, 0,
    45, 0, 0, 0, 0, 70, 0, 0, 0, 0,
    57, 58, 49, 50, 51, 56, 57, 58, 49, 50,
    51, 56, 0, 0, 0, 0, 0, 56, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 57, 58,
    49, 50, 51, 56, 0, 0, 49, 50, 51, 56,
    32, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 30, 0, 21, 31, 0, 34};
int yypact[] = {

    -1000, -258, -1000, -1000, -1000, -234, -1000, 34, -254, -1000,
    -1000, -1000, -1000, 43, -1000, -1000, 40, -1000, -236, -1000,
    -1000, -1000, 93, -9, -1000, 43, 43, 43, 92, -1000,
    -1000, -1000, -1000, -1000, 43, 43, -1000, 43, -240, 62,
    31, -13, 48, 83, -242, -1000, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, -1000, -1000, 90,
    13, -1000, -1000, -248, 43, 19, -15, -216, -1000, 60,
    -1000, -1000, -249, -1000, -1000, 43, -250, 43, 89, 61,
    -1000, -1000, -3, -3, -3, -3, -3, -3, 53, 53,
    -1000, -1000, 82, -1000, -1000, -1000, -2, -1000, 85, 13,
    -1000, 43, -1000, -1000, 31, 43, -36, -1000, 56, 60,
    -1000, -255, -1000, 43, 43, -1000, -269, -1000, -1000, -1000,
    13, 34, -1000, 43, -1000, 13, -1000, -1000, -1000, -1000,
    -193, 19, 19, -53, 59, -1000, -1000, -8, 58, 43,
    -1000, -1000, -1000, -1000, -226, -1000, -218, -223, -1000, 43,
    -1000, -269, 26, -1000, -1000, -1000, 13, -253, 43, -1000,
    -1000, -1000, -42, -1000, 43, 43, -1000, 34, -1000, 13,
    -1000, -1000, -1000, -1000, -193, -1000};
int yypgo[] = {

    0, 195, 50, 96, 71, 135, 194, 193, 192, 190,
    189, 187, 136, 186, 184, 82, 54, 183, 182, 180,
    172, 170, 59, 168, 167, 166, 63, 70, 164, 162,
    137, 161, 160, 159, 158, 157, 156, 155, 154, 153,
    152, 150, 149, 148, 69, 147, 144, 65, 143, 142,
    140, 76, 138};
int yyr1[] = {

    0, 1, 14, 1, 1, 1, 19, 21, 17, 23,
    23, 24, 15, 16, 16, 25, 28, 25, 29, 25,
    25, 25, 25, 27, 27, 27, 32, 33, 22, 34,
    35, 34, 2, 26, 3, 3, 3, 3, 3, 3,
    3, 3, 3, 3, 3, 3, 3, 3, 36, 3,
    3, 3, 3, 3, 3, 3, 3, 38, 3, 39,
    3, 37, 37, 41, 30, 40, 4, 4, 5, 42,
    5, 20, 20, 43, 43, 13, 13, 7, 7, 8,
    8, 9, 9, 45, 44, 10, 10, 46, 11, 48,
    11, 47, 6, 6, 12, 49, 12, 50, 12, 31,
    31, 51, 52, 51, 18};
int yyr2[] = {

    0, 0, 1, 9, 4, 4, 1, 1, 19, 0,
    6, 1, 4, 0, 2, 17, 1, 17, 1, 13,
    7, 3, 4, 0, 4, 15, 1, 1, 9, 0,
    1, 9, 1, 3, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 5, 5, 1, 9,
    9, 3, 3, 3, 3, 3, 5, 1, 11, 1,
    11, 1, 2, 1, 11, 3, 1, 3, 3, 1,
    9, 0, 2, 3, 7, 1, 3, 7, 7, 1,
    3, 3, 7, 1, 9, 1, 3, 1, 5, 1,
    9, 3, 3, 7, 3, 1, 11, 1, 9, 5,
    9, 1, 1, 6, 3};
int yychk[] = {

    -1000, -1, -14, -17, -18, 270, 273, -15, -24, 271,
    -16, 59, -25, 258, 262, 264, -6, -30, 268, -12,
    -40, 271, -19, -26, -3, 40, 43, 45, 64, -12,
    269, 272, 257, -30, 274, -28, -29, 61, 44, -31,
    271, -49, -50, -41, 40, 259, 61, 60, 62, 277,
    278, 279, 43, 45, 42, 47, 280, 275, 276, -3,
    -26, -26, -26, -36, 40, -26, -26, -22, -32, -5,
    -3, -12, 44, -51, 61, 91, 46, 40, -20, -43,
    271, -2, -26, -26, -26, -26, -26, -26, -26, -26,
    -26, -26, -26, -2, -2, 41, -13, 271, -37, -26,
    263, 265, -23, 44, 271, -52, -26, 271, -4, -5,
    41, 44, -22, -38, -39, -7, 123, 91, 41, -2,
    -26, -15, -33, -42, -51, -26, 93, 41, -21, 271,
    -2, -26, -26, -8, -9, -44, 271, -10, -11, -46,
    -22, -2, -16, -34, -35, -3, -22, -27, 260, 261,
    125, 44, -45, 93, 44, -47, -26, -2, 267, 266,
    266, -22, -26, -44, 61, -48, 266, -4, 259, -26,
    -47, -16, -2, -22, -2, -27};
int yydef[] = {

    1, -2, 11, 4, 5, 0, 104, 13, 0, 6,
    3, 14, 12, 0, 16, 18, 0, 21, 0, -2,
    63, 94, 0, 0, 33, 0, 0, 0, 48, -2,
    52, 53, 54, 55, 0, 0, 26, 0, 0, 22,
    101, 0, 0, 0, 71, 32, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 32, 32, 33,
    0, 46, 47, 75, 61, 56, 0, 0, 9, 20,
    -2, -2, 0, 99, 102, 0, 0, 66, 0, 72,
    73, 26, 35, 36, 37, 38, 39, 40, 41, 42,
    43, 44, 45, 57, 59, 34, 0, 76, 0, 62,
    32, 0, -2, 69, 101, 0, 0, 98, 0, 67,
    7, 0, 32, 0, 0, 49, 79, -2, 50, 26,
    32, 13, -2, 0, 100, 103, 96, 64, 26, 74,
    23, 58, 60, 0, 80, 81, 83, 0, 86, 0,
    32, 19, 10, 28, 0, -2, 0, 0, 26, 0,
    77, 0, 0, 78, 89, 88, 91, 0, 66, 8,
    15, 24, 0, 82, 0, 0, 17, 13, 32, 84,
    90, 31, 26, 32, 23, 25};
typedef struct
{
    char *t_name;
    int t_val;
} yytoktype;
#ifndef YYDEBUG
#define YYDEBUG 0 /* don't allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =
    {
        {"NIL", 257},
        {"IF", 258},
        {"THEN", 259},
        {"ELSE", 260},
        {"ELSEIF", 261},
        {"WHILE", 262},
        {"DO", 263},
        {"REPEAT", 264},
        {"UNTIL", 265},
        {"END", 266},
        {"RETURN", 267},
        {"LOCAL", 268},
        {"NUMBER", 269},
        {"FUNCTION", 270},
        {"NAME", 271},
        {"STRING", 272},
        {"DEBUG", 273},
        {"NOT", 274},
        {"AND", 275},
        {"OR", 276},
        {"=", 61},
        {"NE", 277},
        {">", 62},
        {"<", 60},
        {"LE", 278},
        {"GE", 279},
        {"CONC", 280},
        {"+", 43},
        {"-", 45},
        {"*", 42},
        {"/", 47},
        {"%", 37},
        {"UNARY", 281},
        {"-unknown-", -1} /* ends search */
};

char *yyreds[] =
    {
        "-no such reduction-",
        "functionlist : /* empty */",
        "functionlist : functionlist",
        "functionlist : functionlist stat sc",
        "functionlist : functionlist function",
        "functionlist : functionlist setdebug",
        "function : FUNCTION NAME",
        "function : FUNCTION NAME '(' parlist ')'",
        "function : FUNCTION NAME '(' parlist ')' block END",
        "statlist : /* empty */",
        "statlist : statlist stat sc",
        "stat : /* empty */",
        "stat : stat1",
        "sc : /* empty */",
        "sc : ';'",
        "stat1 : IF expr1 THEN PrepJump block PrepJump elsepart END",
        "stat1 : WHILE",
        "stat1 : WHILE expr1 DO PrepJump block PrepJump END",
        "stat1 : REPEAT",
        "stat1 : REPEAT block UNTIL expr1 PrepJump",
        "stat1 : varlist1 '=' exprlist1",
        "stat1 : functioncall",
        "stat1 : LOCAL declist",
        "elsepart : /* empty */",
        "elsepart : ELSE block",
        "elsepart : ELSEIF expr1 THEN PrepJump block PrepJump elsepart",
        "block : /* empty */",
        "block : statlist",
        "block : statlist ret",
        "ret : /* empty */",
        "ret : /* empty */",
        "ret : RETURN exprlist sc",
        "PrepJump : /* empty */",
        "expr1 : expr",
        "expr : '(' expr ')'",
        "expr : expr1 '=' expr1",
        "expr : expr1 '<' expr1",
        "expr : expr1 '>' expr1",
        "expr : expr1 NE expr1",
        "expr : expr1 LE expr1",
        "expr : expr1 GE expr1",
        "expr : expr1 '+' expr1",
        "expr : expr1 '-' expr1",
        "expr : expr1 '*' expr1",
        "expr : expr1 '/' expr1",
        "expr : expr1 CONC expr1",
        "expr : '+' expr1",
        "expr : '-' expr1",
        "expr : '@'",
        "expr : '@' objectname fieldlist",
        "expr : '@' '(' dimension ')'",
        "expr : var",
        "expr : NUMBER",
        "expr : STRING",
        "expr : NIL",
        "expr : functioncall",
        "expr : NOT expr1",
        "expr : expr1 AND PrepJump",
        "expr : expr1 AND PrepJump expr1",
        "expr : expr1 OR PrepJump",
        "expr : expr1 OR PrepJump expr1",
        "dimension : /* empty */",
        "dimension : expr1",
        "functioncall : functionvalue",
        "functioncall : functionvalue '(' exprlist ')'",
        "functionvalue : var",
        "exprlist : /* empty */",
        "exprlist : exprlist1",
        "exprlist1 : expr",
        "exprlist1 : exprlist1 ','",
        "exprlist1 : exprlist1 ',' expr",
        "parlist : /* empty */",
        "parlist : parlist1",
        "parlist1 : NAME",
        "parlist1 : parlist1 ',' NAME",
        "objectname : /* empty */",
        "objectname : NAME",
        "fieldlist : '{' ffieldlist '}'",
        "fieldlist : '[' lfieldlist ']'",
        "ffieldlist : /* empty */",
        "ffieldlist : ffieldlist1",
        "ffieldlist1 : ffield",
        "ffieldlist1 : ffieldlist1 ',' ffield",
        "ffield : NAME",
        "ffield : NAME '=' expr1",
        "lfieldlist : /* empty */",
        "lfieldlist : lfieldlist1",
        "lfieldlist1 : /* empty */",
        "lfieldlist1 : lfield",
        "lfieldlist1 : lfieldlist1 ','",
        "lfieldlist1 : lfieldlist1 ',' lfield",
        "lfield : expr1",
        "varlist1 : var",
        "varlist1 : varlist1 ',' var",
        "var : NAME",
        "var : var",
        "var : var '[' expr1 ']'",
        "var : var",
        "var : var '.' NAME",
        "declist : NAME init",
        "declist : declist ',' NAME init",
        "init : /* empty */",
        "init : '='",
        "init : '=' expr1",
        "setdebug : DEBUG",
};
#endif /* YYDEBUG */
#line 1 "/usr/lib/yaccpar"
/*	@(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10	*/

/*
** Skeleton parser driver for yacc output
*/

/*
** yacc user known macros and defines
*/
#define YYERROR goto yyerrlab
#define YYACCEPT    \
    {               \
        free(yys);  \
        free(yyv);  \
        return (0); \
    }
#define YYABORT     \
    {               \
        free(yys);  \
        free(yyv);  \
        return (1); \
    }
#define YYBACKUP(newtoken, newvalue)                 \
    {                                                \
        if (yychar >= 0 || (yyr2[yytmp] >> 1) != 1)  \
        {                                            \
            yyerror("syntax error - cannot backup"); \
            goto yyerrlab;                           \
        }                                            \
        yychar = newtoken;                           \
        yystate = *yyps;                             \
        yylval = newvalue;                           \
        goto yynewstate;                             \
    }
#define YYRECOVERING() (!!yyerrflag)
#ifndef YYDEBUG
#define YYDEBUG 1 /* make debugging available */
#endif

/*
** user known globals
*/
int yydebug; /* set to 1 to get debugging */

/*
** driver internal defines
*/
#define YYFLAG (-1000)

/*
** static variables used by the parser
*/
static YYSTYPE *yyv; /* value stack */
static int *yys;     /* state stack */

static YYSTYPE *yypv; /* top of value stack */
static int *yyps;     /* top of state stack */

static int yystate; /* current state */
static int yytmp;   /* extra var (lasts between blocks) */

int yynerrs; /* number of errors */

int yyerrflag; /* error recovery flag */
int yychar;    /* current input token number */

/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int yyparse()
{
    register YYSTYPE *yypvt; /* top of value stack for $vars */
    unsigned yymaxdepth = YYMAXDEPTH;

    /*
	** Initialize externals - yyparse may be called more than once
	*/
    yyv = (YYSTYPE *)malloc(yymaxdepth * sizeof(YYSTYPE));
    yys = (int *)malloc(yymaxdepth * sizeof(int));
    if (!yyv || !yys)
    {
        yyerror("out of memory");
        return (1);
    }
    yypv = &yyv[-1];
    yyps = &yys[-1];
    yystate = 0;
    yytmp = 0;
    yynerrs = 0;
    yyerrflag = 0;
    yychar = -1;

    goto yystack;
    {
        register YYSTYPE *yy_pv; /* top of value stack */
        register int *yy_ps;     /* top of state stack */
        register int yy_state;   /* current state */
        register int yy_n;       /* internal state number info */

        /*
		** get globals into registers.
		** branch to here only if YYBACKUP was called.
		*/
    yynewstate:
        yy_pv = yypv;
        yy_ps = yyps;
        yy_state = yystate;
        goto yy_newstate;

        /*
		** get globals into registers.
		** either we just started, or we just finished a reduction
		*/
    yystack:
        yy_pv = yypv;
        yy_ps = yyps;
        yy_state = yystate;

        /*
		** top of for (;;) loop while no reductions done
		*/
    yy_stack:
        /*
		** put a state and value onto the stacks
		*/
#if YYDEBUG
        /*
		** if debugging, look up token value in list of value vs.
		** name pairs.  0 and negative (-1) are special values.
		** Note: linear search is used since time is not a real
		** consideration while debugging.
		*/
        if (yydebug)
        {
            register int yy_i;

            (void)printf("State %d, token ", yy_state);
            if (yychar == 0)
                (void)printf("end-of-file\n");
            else if (yychar < 0)
                (void)printf("-none-\n");
            else
            {
                for (yy_i = 0; yytoks[yy_i].t_val >= 0;
                     yy_i++)
                {
                    if (yytoks[yy_i].t_val == yychar)
                        break;
                }
                (void)printf("%s\n", yytoks[yy_i].t_name);
            }
        }
#endif                                   /* YYDEBUG */
        if (++yy_ps >= &yys[yymaxdepth]) /* room on stack? */
        {
            /*
			** reallocate and recover.  Note that pointers
			** have to be reset, or bad things will happen
			*/
            int yyps_index = (yy_ps - yys);
            int yypv_index = (yy_pv - yyv);
            int yypvt_index = (yypvt - yyv);
            yymaxdepth += YYMAXDEPTH;
            yyv = (YYSTYPE *)realloc((char *)yyv,
                                     yymaxdepth * sizeof(YYSTYPE));
            yys = (int *)realloc((char *)yys,
                                 yymaxdepth * sizeof(int));
            if (!yyv || !yys)
            {
                yyerror("yacc stack overflow");
                return (1);
            }
            yy_ps = yys + yyps_index;
            yy_pv = yyv + yypv_index;
            yypvt = yyv + yypvt_index;
        }
        *yy_ps = yy_state;
        *++yy_pv = yyval;

        /*
		** we have a new state - find out what to do
		*/
    yy_newstate:
        if ((yy_n = yypact[yy_state]) <= YYFLAG)
            goto yydefault; /* simple state */
#if YYDEBUG
        /*
		** if debugging, need to mark whether new token grabbed
		*/
        yytmp = yychar < 0;
#endif
        if ((yychar < 0) && ((yychar = yylex()) < 0))
            yychar = 0; /* reached EOF */
#if YYDEBUG
        if (yydebug && yytmp)
        {
            register int yy_i;

            (void)printf("Received token ");
            if (yychar == 0)
                (void)printf("end-of-file\n");
            else if (yychar < 0)
                (void)printf("-none-\n");
            else
            {
                for (yy_i = 0; yytoks[yy_i].t_val >= 0;
                     yy_i++)
                {
                    if (yytoks[yy_i].t_val == yychar)
                        break;
                }
                (void)printf("%s\n", yytoks[yy_i].t_name);
            }
        }
#endif /* YYDEBUG */
        if (((yy_n += yychar) < 0) || (yy_n >= YYLAST))
            goto yydefault;
        if (yychk[yy_n = yyact[yy_n]] == yychar) /*valid shift*/
        {
            yychar = -1;
            yyval = yylval;
            yy_state = yy_n;
            if (yyerrflag > 0)
                yyerrflag--;
            goto yy_stack;
        }

    yydefault:
        if ((yy_n = yydef[yy_state]) == -2)
        {
#if YYDEBUG
            yytmp = yychar < 0;
#endif
            if ((yychar < 0) && ((yychar = yylex()) < 0))
                yychar = 0; /* reached EOF */
#if YYDEBUG
            if (yydebug && yytmp)
            {
                register int yy_i;

                (void)printf("Received token ");
                if (yychar == 0)
                    (void)printf("end-of-file\n");
                else if (yychar < 0)
                    (void)printf("-none-\n");
                else
                {
                    for (yy_i = 0;
                         yytoks[yy_i].t_val >= 0;
                         yy_i++)
                    {
                        if (yytoks[yy_i].t_val == yychar)
                        {
                            break;
                        }
                    }
                    (void)printf("%s\n", yytoks[yy_i].t_name);
                }
            }
#endif /* YYDEBUG */
            /*
			** look through exception table
			*/
            {
                register int *yyxi = yyexca;

                while ((*yyxi != -1) ||
                       (yyxi[1] != yy_state))
                {
                    yyxi += 2;
                }
                while ((*(yyxi += 2) >= 0) &&
                       (*yyxi != yychar))
                    ;
                if ((yy_n = yyxi[1]) < 0)
                    YYACCEPT;
            }
        }

        /*
		** check for syntax error
		*/
        if (yy_n == 0) /* have an error */
        {
            /* no worry about speed here! */
            switch (yyerrflag)
            {
            case 0: /* new error */
                yyerror("syntax error");
                goto skip_init;
            yyerrlab:
                /*
				** get globals into registers.
				** we have a user generated syntax type error
				*/
                yy_pv = yypv;
                yy_ps = yyps;
                yy_state = yystate;
                yynerrs++;
            skip_init:
            case 1:
            case 2: /* incompletely recovered error */
                    /* try again... */
                yyerrflag = 3;
                /*
				** find state where "error" is a legal
				** shift action
				*/
                while (yy_ps >= yys)
                {
                    yy_n = yypact[*yy_ps] + YYERRCODE;
                    if (yy_n >= 0 && yy_n < YYLAST &&
                        yychk[yyact[yy_n]] == YYERRCODE)
                    {
                        /*
						** simulate shift of "error"
						*/
                        yy_state = yyact[yy_n];
                        goto yy_stack;
                    }
                    /*
					** current state has no shift on
					** "error", pop stack
					*/
#if YYDEBUG
#define _POP_ "Error recovery pops state %d, uncovers state %d\n"
                    if (yydebug)
                        (void)printf(_POP_, *yy_ps,
                                     yy_ps[-1]);
#undef _POP_
#endif
                    yy_ps--;
                    yy_pv--;
                }
                /*
				** there is no state on stack with "error" as
				** a valid shift.  give up.
				*/
                YYABORT;
            case 3: /* no shift yet; eat a token */
#if YYDEBUG
                /*
				** if debugging, look up token in list of
				** pairs.  0 and negative shouldn't occur,
				** but since timing doesn't matter when
				** debugging, it doesn't hurt to leave the
				** tests here.
				*/
                if (yydebug)
                {
                    register int yy_i;

                    (void)printf("Error recovery discards ");
                    if (yychar == 0)
                        (void)printf("token end-of-file\n");
                    else if (yychar < 0)
                        (void)printf("token -none-\n");
                    else
                    {
                        for (yy_i = 0;
                             yytoks[yy_i].t_val >= 0;
                             yy_i++)
                        {
                            if (yytoks[yy_i].t_val == yychar)
                            {
                                break;
                            }
                        }
                        (void)printf("token %s\n",
                                     yytoks[yy_i].t_name);
                    }
                }
#endif                           /* YYDEBUG */
                if (yychar == 0) /* reached EOF. quit */
                    YYABORT;
                yychar = -1;
                goto yy_newstate;
            }
        } /* end if ( yy_n == 0 ) */
          /*
		** reduction by production yy_n
		** put stack tops, etc. so things right after switch
		*/
#if YYDEBUG
        /*
		** if debugging, print the string that is the user's
		** specification of the reduction which is just about
		** to be done.
		*/
        if (yydebug)
            (void)printf("Reduce by (%d) \"%s\"\n",
                         yy_n, yyreds[yy_n]);
#endif
        yytmp = yy_n;  /* value to switch over */
        yypvt = yy_pv; /* $vars top of value stack */
        /*
		** Look in goto table for next state
		** Sorry about using yy_state here as temporary
		** register variable, but why not, if it works...
		** If yyr2[ yy_n ] doesn't have the low order bit
		** set, then there is no action to be done for
		** this reduction.  So, no saving & unsaving of
		** registers done.  The only difference between the
		** code just after the if and the body of the if is
		** the goto yy_stack in the body.  This way the test
		** can be made before the choice of what to do is needed.
		*/
        {
            /* length of production doubled with extra bit */
            register int yy_len = yyr2[yy_n];

            if (!(yy_len & 01))
            {
                yy_len >>= 1;
                yyval = (yy_pv -= yy_len)[1]; /* $$ = $1 */
                yy_state = yypgo[yy_n = yyr1[yy_n]] +
                           *(yy_ps -= yy_len) + 1;
                if (yy_state >= YYLAST ||
                    yychk[yy_state =
                              yyact[yy_state]] != -yy_n)
                {
                    yy_state = yyact[yypgo[yy_n]];
                }
                goto yy_stack;
            }
            yy_len >>= 1;
            yyval = (yy_pv -= yy_len)[1]; /* $$ = $1 */
            yy_state = yypgo[yy_n = yyr1[yy_n]] +
                       *(yy_ps -= yy_len) + 1;
            if (yy_state >= YYLAST ||
                yychk[yy_state = yyact[yy_state]] != -yy_n)
            {
                yy_state = yyact[yypgo[yy_n]];
            }
        }
        /* save until reenter driver code */
        yystate = yy_state;
        yyps = yy_ps;
        yypv = yy_pv;
    }
    /*
	** code supplied by user is placed in this switch
	*/
    switch (yytmp)
    {

    case 2:
#line 179 "lua.stx"
    {
        pc = basepc = maincode;
        nlocalvar = 0;
    }
    break;
    case 3:
#line 179 "lua.stx"
    {
        maincode = pc;
    }
    break;
    case 6:
#line 184 "lua.stx"
    {
        pc = basepc = code;
        nlocalvar = 0;
    }
    break;
    case 7:
#line 185 "lua.stx"
    {
        if (lua_debug)
        {
            align(Word);
            code_byte(SETFUNCTION);
            code_word(yypvt[-5].vWord);
            code_word(yypvt[-4].vWord);
        }
        lua_codeadjust(0);
    }
    break;
    case 8:
#line 197 "lua.stx"
    {
        if (lua_debug)
            code_byte(RESET);
        code_byte(RETCODE);
        code_byte(nlocalvar);
        s_tag(yypvt[-7].vWord) = T_FUNCTION;
        s_bvalue(yypvt[-7].vWord) = calloc(pc - code, sizeof(Byte));
        memcpy(s_bvalue(yypvt[-7].vWord), code, (pc - code) * sizeof(Byte));
    }
    break;
    case 11:
#line 210 "lua.stx"
    {
        ntemp = 0;
        if (lua_debug)
        {
            align(Word);
            code_byte(SETLINE);
            code_word(lua_linenumber);
        }
    }
    break;
    case 15:
#line 223 "lua.stx"
    {
        {
            Byte *elseinit = yypvt[-2].pByte + sizeof(Word) + 1;
            if (pc - elseinit == 0) /* no else */
            {
                pc -= sizeof(Word) + 1;
                /* if (*(pc-1) == NOP) --pc; */
                elseinit = pc;
            }
            else
            {
                *(yypvt[-2].pByte) = JMP;
                *((Word *)(yypvt[-2].pByte + 1)) = pc - elseinit;
            }
            *(yypvt[-4].pByte) = IFFJMP;
            *((Word *)(yypvt[-4].pByte + 1)) = elseinit - (yypvt[-4].pByte + sizeof(Word) + 1);
        }
    }
    break;
    case 16:
#line 242 "lua.stx"
    {
        yyval.pByte = pc;
    }
    break;
    case 17:
#line 244 "lua.stx"
    {
        *(yypvt[-3].pByte) = IFFJMP;
        *((Word *)(yypvt[-3].pByte + 1)) = pc - (yypvt[-3].pByte + sizeof(Word) + 1);

        *(yypvt[-1].pByte) = UPJMP;
        *((Word *)(yypvt[-1].pByte + 1)) = pc - yypvt[-6].pByte;
    }
    break;
    case 18:
#line 252 "lua.stx"
    {
        yyval.pByte = pc;
    }
    break;
    case 19:
#line 254 "lua.stx"
    {
        *(yypvt[-0].pByte) = IFFUPJMP;
        *((Word *)(yypvt[-0].pByte + 1)) = pc - yypvt[-4].pByte;
    }
    break;
    case 20:
#line 261 "lua.stx"
    {
        {
            int i;
            if (yypvt[-0].vInt == 0 || nvarbuffer != ntemp - yypvt[-2].vInt * 2)
                lua_codeadjust(yypvt[-2].vInt * 2 + nvarbuffer);
            for (i = nvarbuffer - 1; i >= 0; i--)
                lua_codestore(i);
            if (yypvt[-2].vInt > 1 || (yypvt[-2].vInt == 1 && varbuffer[0] != 0))
                lua_codeadjust(0);
        }
    }
    break;
    case 21:
#line 272 "lua.stx"
    {
        lua_codeadjust(0);
    }
    break;
    case 25:
#line 279 "lua.stx"
    {
        {
            Byte *elseinit = yypvt[-1].pByte + sizeof(Word) + 1;
            if (pc - elseinit == 0) /* no else */
            {
                pc -= sizeof(Word) + 1;
                /* if (*(pc-1) == NOP) --pc; */
                elseinit = pc;
            }
            else
            {
                *(yypvt[-1].pByte) = JMP;
                *((Word *)(yypvt[-1].pByte + 1)) = pc - elseinit;
            }
            *(yypvt[-3].pByte) = IFFJMP;
            *((Word *)(yypvt[-3].pByte + 1)) = elseinit - (yypvt[-3].pByte + sizeof(Word) + 1);
        }
    }
    break;
    case 26:
#line 299 "lua.stx"
    {
        yyval.vInt = nlocalvar;
    }
    break;
    case 27:
#line 299 "lua.stx"
    {
        ntemp = 0;
    }
    break;
    case 28:
#line 300 "lua.stx"
    {
        if (nlocalvar != yypvt[-3].vInt)
        {
            nlocalvar = yypvt[-3].vInt;
            lua_codeadjust(0);
        }
    }
    break;
    case 30:
#line 310 "lua.stx"
    {
        if (lua_debug)
        {
            align(Word);
            code_byte(SETLINE);
            code_word(lua_linenumber);
        }
    }
    break;
    case 31:
#line 312 "lua.stx"
    {
        if (lua_debug)
            code_byte(RESET);
        code_byte(RETCODE);
        code_byte(nlocalvar);
    }
    break;
    case 32:
#line 319 "lua.stx"
    {
        align(Word);
        yyval.pByte = pc;
        code_byte(0); /* open space */
        code_word(0);
    }
    break;
    case 33:
#line 326 "lua.stx"
    {
        if (yypvt[-0].vInt == 0)
        {
            lua_codeadjust(ntemp + 1);
            incr_ntemp();
        }
    }
    break;
    case 34:
#line 329 "lua.stx"
    {
        yyval.vInt = yypvt[-1].vInt;
    }
    break;
    case 35:
#line 330 "lua.stx"
    {
        code_byte(EQOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 36:
#line 331 "lua.stx"
    {
        code_byte(LTOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 37:
#line 332 "lua.stx"
    {
        code_byte(LEOP);
        code_byte(NOTOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 38:
#line 333 "lua.stx"
    {
        code_byte(EQOP);
        code_byte(NOTOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 39:
#line 334 "lua.stx"
    {
        code_byte(LEOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 40:
#line 335 "lua.stx"
    {
        code_byte(LTOP);
        code_byte(NOTOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 41:
#line 336 "lua.stx"
    {
        code_byte(ADDOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 42:
#line 337 "lua.stx"
    {
        code_byte(SUBOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 43:
#line 338 "lua.stx"
    {
        code_byte(MULTOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 44:
#line 339 "lua.stx"
    {
        code_byte(DIVOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 45:
#line 340 "lua.stx"
    {
        code_byte(CONCOP);
        yyval.vInt = 1;
        ntemp--;
    }
    break;
    case 46:
#line 341 "lua.stx"
    {
        yyval.vInt = 1;
    }
    break;
    case 47:
#line 342 "lua.stx"
    {
        code_byte(MINUSOP);
        yyval.vInt = 1;
    }
    break;
    case 48:
#line 344 "lua.stx"
    {
        code_byte(PUSHBYTE);
        yyval.pByte = pc;
        code_byte(0);
        incr_ntemp();
        code_byte(CREATEARRAY);
    }
    break;
    case 49:
#line 351 "lua.stx"
    {
        *(yypvt[-2].pByte) = yypvt[-0].vInt;
        if (yypvt[-1].vLong < 0) /* there is no function to be called */
        {
            yyval.vInt = 1;
        }
        else
        {
            lua_pushvar(yypvt[-1].vLong + 1);
            code_byte(PUSHMARK);
            incr_ntemp();
            code_byte(PUSHOBJECT);
            incr_ntemp();
            code_byte(CALLFUNC);
            ntemp -= 4;
            yyval.vInt = 0;
            if (lua_debug)
            {
                align(Word);
                code_byte(SETLINE);
                code_word(lua_linenumber);
            }
        }
    }
    break;
    case 50:
#line 374 "lua.stx"
    {
        code_byte(CREATEARRAY);
        yyval.vInt = 1;
    }
    break;
    case 51:
#line 378 "lua.stx"
    {
        lua_pushvar(yypvt[-0].vLong);
        yyval.vInt = 1;
    }
    break;
    case 52:
#line 379 "lua.stx"
    {
        code_number(yypvt[-0].vFloat);
        yyval.vInt = 1;
    }
    break;
    case 53:
#line 381 "lua.stx"
    {
        align(Word);
        code_byte(PUSHSTRING);
        code_word(yypvt[-0].vWord);
        yyval.vInt = 1;
        incr_ntemp();
    }
    break;
    case 54:
#line 388 "lua.stx"
    {
        code_byte(PUSHNIL);
        yyval.vInt = 1;
        incr_ntemp();
    }
    break;
    case 55:
#line 390 "lua.stx"
    {
        yyval.vInt = 0;
        if (lua_debug)
        {
            align(Word);
            code_byte(SETLINE);
            code_word(lua_linenumber);
        }
    }
    break;
    case 56:
#line 397 "lua.stx"
    {
        code_byte(NOTOP);
        yyval.vInt = 1;
    }
    break;
    case 57:
#line 398 "lua.stx"
    {
        code_byte(POP);
        ntemp--;
    }
    break;
    case 58:
#line 399 "lua.stx"
    {
        *(yypvt[-2].pByte) = ONFJMP;
        *((Word *)(yypvt[-2].pByte + 1)) = pc - (yypvt[-2].pByte + sizeof(Word) + 1);
        yyval.vInt = 1;
    }
    break;
    case 59:
#line 404 "lua.stx"
    {
        code_byte(POP);
        ntemp--;
    }
    break;
    case 60:
#line 405 "lua.stx"
    {
        *(yypvt[-2].pByte) = ONTJMP;
        *((Word *)(yypvt[-2].pByte + 1)) = pc - (yypvt[-2].pByte + sizeof(Word) + 1);
        yyval.vInt = 1;
    }
    break;
    case 61:
#line 412 "lua.stx"
    {
        code_byte(PUSHNIL);
        incr_ntemp();
    }
    break;
    case 63:
#line 416 "lua.stx"
    {
        code_byte(PUSHMARK);
        yyval.vInt = ntemp;
        incr_ntemp();
    }
    break;
    case 64:
#line 417 "lua.stx"
    {
        code_byte(CALLFUNC);
        ntemp = yypvt[-3].vInt - 1;
    }
    break;
    case 65:
#line 419 "lua.stx"
    {
        lua_pushvar(yypvt[-0].vLong);
    }
    break;
    case 66:
#line 422 "lua.stx"
    {
        yyval.vInt = 1;
    }
    break;
    case 67:
#line 423 "lua.stx"
    {
        yyval.vInt = yypvt[-0].vInt;
    }
    break;
    case 68:
#line 426 "lua.stx"
    {
        yyval.vInt = yypvt[-0].vInt;
    }
    break;
    case 69:
#line 427 "lua.stx"
    {
        if (!yypvt[-1].vInt)
        {
            lua_codeadjust(ntemp + 1);
            incr_ntemp();
        }
    }
    break;
    case 70:
#line 428 "lua.stx"
    {
        yyval.vInt = yypvt[-0].vInt;
    }
    break;
    case 73:
#line 435 "lua.stx"
    {
        localvar[nlocalvar] = yypvt[-0].vWord;
        incr_nlocalvar();
    }
    break;
    case 74:
#line 436 "lua.stx"
    {
        localvar[nlocalvar] = yypvt[-0].vWord;
        incr_nlocalvar();
    }
    break;
    case 75:
#line 439 "lua.stx"
    {
        yyval.vLong = -1;
    }
    break;
    case 76:
#line 440 "lua.stx"
    {
        yyval.vLong = yypvt[-0].vWord;
    }
    break;
    case 77:
#line 443 "lua.stx"
    {
        yyval.vInt = yypvt[-1].vInt;
    }
    break;
    case 78:
#line 444 "lua.stx"
    {
        yyval.vInt = yypvt[-1].vInt;
    }
    break;
    case 79:
#line 447 "lua.stx"
    {
        yyval.vInt = 0;
    }
    break;
    case 80:
#line 448 "lua.stx"
    {
        yyval.vInt = yypvt[-0].vInt;
    }
    break;
    case 81:
#line 451 "lua.stx"
    {
        yyval.vInt = 1;
    }
    break;
    case 82:
#line 452 "lua.stx"
    {
        yyval.vInt = yypvt[-2].vInt + 1;
    }
    break;
    case 83:
#line 456 "lua.stx"
    {
        align(Word);
        code_byte(PUSHSTRING);
        code_word(lua_findconstant(s_name(yypvt[-0].vWord)));
        incr_ntemp();
    }
    break;
    case 84:
#line 463 "lua.stx"
    {
        code_byte(STOREFIELD);
        ntemp -= 2;
    }
    break;
    case 85:
#line 469 "lua.stx"
    {
        yyval.vInt = 0;
    }
    break;
    case 86:
#line 470 "lua.stx"
    {
        yyval.vInt = yypvt[-0].vInt;
    }
    break;
    case 87:
#line 473 "lua.stx"
    {
        code_number(1);
    }
    break;
    case 88:
#line 473 "lua.stx"
    {
        yyval.vInt = 1;
    }
    break;
    case 89:
#line 474 "lua.stx"
    {
        code_number(yypvt[-1].vInt + 1);
    }
    break;
    case 90:
#line 475 "lua.stx"
    {
        yyval.vInt = yypvt[-3].vInt + 1;
    }
    break;
    case 91:
#line 479 "lua.stx"
    {
        code_byte(STOREFIELD);
        ntemp -= 2;
    }
    break;
    case 92:
#line 486 "lua.stx"
    {
        nvarbuffer = 0;
        varbuffer[nvarbuffer] = yypvt[-0].vLong;
        incr_nvarbuffer();
        yyval.vInt = (yypvt[-0].vLong == 0) ? 1 : 0;
    }
    break;
    case 93:
#line 492 "lua.stx"
    {
        varbuffer[nvarbuffer] = yypvt[-0].vLong;
        incr_nvarbuffer();
        yyval.vInt = (yypvt[-0].vLong == 0) ? yypvt[-2].vInt + 1 : yypvt[-2].vInt;
    }
    break;
    case 94:
#line 499 "lua.stx"
    {
        int local = lua_localname(yypvt[-0].vWord);
        if (local == -1)                       /* global var */
            yyval.vLong = yypvt[-0].vWord + 1; /* return positive value */
        else
            yyval.vLong = -(local + 1); /* return negative value */
    }
    break;
    case 95:
#line 507 "lua.stx"
    {
        lua_pushvar(yypvt[-0].vLong);
    }
    break;
    case 96:
#line 508 "lua.stx"
    {
        yyval.vLong = 0; /* indexed variable */
    }
    break;
    case 97:
#line 511 "lua.stx"
    {
        lua_pushvar(yypvt[-0].vLong);
    }
    break;
    case 98:
#line 512 "lua.stx"
    {
        align(Word);
        code_byte(PUSHSTRING);
        code_word(lua_findconstant(s_name(yypvt[-0].vWord)));
        incr_ntemp();
        yyval.vLong = 0; /* indexed variable */
    }
    break;
    case 99:
#line 520 "lua.stx"
    {
        localvar[nlocalvar] = yypvt[-1].vWord;
        incr_nlocalvar();
    }
    break;
    case 100:
#line 521 "lua.stx"
    {
        localvar[nlocalvar] = yypvt[-1].vWord;
        incr_nlocalvar();
    }
    break;
    case 101:
#line 524 "lua.stx"
    {
        code_byte(PUSHNIL);
    }
    break;
    case 102:
#line 525 "lua.stx"
    {
        ntemp = 0;
    }
    break;
    case 104:
#line 528 "lua.stx"
    {
        lua_debug = yypvt[-0].vInt;
    }
    break;
    }
    goto yystack; /* reset registers in driver code */
    return (0);
}
